﻿// Allgemeine Funktionalität für Netzwerk-Programmierung
using System.Net;
// Funktionalitäten speziell für die Verbindungsverwaltung
using System.Net.Sockets;
// Funktionalitäten für die Prozess-Erstellung und -Verwaltung
using System.Threading;
using System.IO;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    public class Receiver
    {

// ---------------------------------------------- Deklaration der Variablen ----------------------------------------------

        private TcpClient client;
        private StreamReader reader;
        private String messageFromServer;

        private Connector connector;
        private List<string> liste = new List<string>();

        private int startID = -1;
        private int endID = -1;

        //public bool blocked;
// --------------------------------------------- Konstruktor Initialisierung ---------------------------------------------
        /*
         * Konstruktor des Recievers initialisiert die Client-Variable
         * und holt dessen Stream außerdem erzeugt er
         * einen neuen StreamReader
         * @param client  bekommt einen TcpClient übergeben
         */
        public Receiver(TcpClient client, Connector connector)
        {
            this.client = client;
            this.reader = new StreamReader(client.GetStream());
            this.connector = connector;
        }
        
// ------------------------------------------------ öffentliche Methoden -------------------------------------------------
        /*
        * Methode zum Message-Empfangen von den Server
        * wird im Thread als Endlosschleife durchgeführt um vom Server
        * ständig Updates über das Spiel zu empfangen
        */
        public void GetMessageFromServer()
        {
            while (true)
            {
            try
               {
                       String message = reader.ReadLine();
                       String[] tempMessage = message.Split(':');
                       //Console.WriteLine(message);

                       if (startID == -1)
                       {
                           //Console.WriteLine("@ BEGIN ID");
                           if (tempMessage[0].Equals("begin"))
                           {
                               int tempNumber;
                               bool isDigit = Int32.TryParse(tempMessage[1], out tempNumber);
                               if (isDigit)
                               {
                                   startID = tempNumber;
                               }
                           }
                       }
                       else if (endID == -1)
                       {
                           //Console.WriteLine("@END ID");
                           if (tempMessage[0].Equals("end"))
                           {
                               int tempNumber = -1;
                               bool isDigit = Int32.TryParse(tempMessage[1], out tempNumber);

                               //Console.WriteLine("END ID: " + tempMessage[1] + " == " + tempNumber+" BOOL:"+isDigit);

                               if (isDigit)
                               {
                                   if (tempNumber == startID)
                                   {
                                       //Console.WriteLine("SAME ID'S");
                                       endID = tempNumber;
                                   }
                               }
                           }
                       }

                       liste.Add(message);

                       if ((startID != -1) && (endID != -1))
                       {
                           if (!this.connector.Puffer.IsFull())
                           {
                               lock (this.connector.Puffer)
                               {
                                   this.connector.writeListToPuffer(liste);
                               }
                               liste.Clear();
                               startID = -1;
                               endID = -1;
                           }
                           else
                           {
                               Console.WriteLine("Puffer ist voll. Fehler beim Speichern neuer Servernachricht!");
                           }
                       }

            }
            catch (Exception e)
            {
                Console.WriteLine("RECIEVER: "+e.Message);
            }
            
            }
        }


// ----------------------------------------------- Getter/Setter-Methoden -----------------------------------------------

        /*
         * Getter/Setter-Methode für die serverseitige Nachricht
         * @return gibt den String mit der Servernachricht zurück und kann weiter verarbeitet werden
         */
        public String MessageFromServer
        {
            get
            {
                return messageFromServer;
            }
            set
            {
                this.messageFromServer = value;
            }
        }


        /*
         * Getter/Setter-Methode für den Client, zur Speicherung des Clients um diesen weiter zu verwenden
         * Sowie die Abfrage auf den Client
         * @return gibt das Clientobjekt zurück
         */
        public TcpClient Client
        {
            get
            {
                return client;
            }
            set
            {
                this.client = value;
            }
        }

        /*
         * Getter/Setter-Methode für den Writer
         * Methode zum Aufbau des Writers um Nachrichten an den Server zu senden
         * @return gibt ein Objekt des Writers zurück
         */
        public StreamReader Reader
        {
            get
            {
                return reader;
            }
            set
            {
                this.reader = value;
            }
        }

    }
}
